home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / simcode.arc / XRECV.C < prev    next >
Text File  |  1984-11-29  |  6KB  |  276 lines
  1. char soh = 0x01;
  2. char eot = 0x04;
  3. char ack = 0x06;
  4. char nak = 0x15;
  5. char can = 0x18;
  6. #include "stdio.h"
  7. #include "signal.h"
  8. #include "termio.h"
  9. #include "sys/ioctl.h"
  10. struct termio save;
  11. struct termio new;
  12.  
  13. int lfproc = 0;
  14. int debug = 0;
  15. int remote = 0;
  16. FILE *errors;
  17. main(argc, argv)
  18. int argc;
  19. char **argv;
  20. {
  21.     int i,j;
  22.     char buf[130];
  23.     char remote_name[70];
  24.     char blocknum = 1;
  25.     char c_blocknum = 254;
  26.     int numread;
  27.     char cksum;
  28.     char inch;
  29.     int alarmfn();
  30.     int kleenex();
  31.     FILE *fp;
  32.     extern char *optarg;
  33.     extern int optind;
  34.     char file[128];
  35.  
  36.     ioctl(1, TCGETA, &save);
  37.     ioctl(1, TCGETA, &new);
  38.     while ((i = getopt(argc, argv, "lrtd")) != EOF)
  39.         switch(i) {
  40.         case 'd':
  41.             debug++;
  42.             break;
  43.         case 'l':
  44.         case 't':    /* TEXT file */
  45.             lfproc++;
  46.             break;
  47.         case 'r':    /* remote file */
  48.             remote++;
  49.             break;
  50.         case '?':
  51.             fprintf(stderr, "Usage: %s [-d] file\n", argv[0]);
  52.             kleenex(0);
  53.             break;
  54.         }
  55.     if (debug) errors = fopen("xr.err", "w");
  56.     if (debug && errors == NULL) {
  57.         fprintf(stderr, "Unable to open xr.err for error tracing\n");
  58.         kleenex(1);
  59.     }
  60.     if (debug) setbuf(errors, NULL);
  61.     if (argc == 1 || argc == optind) {
  62.         fprintf(stderr, "Need file name\n");
  63.         kleenex(0);
  64.     }
  65.     strcpy(file, argv[optind]);
  66.     for (i=1; i<20;i++) signal(i, SIG_IGN);
  67.     signal(14, alarmfn);
  68.     signal(3, kleenex);
  69.     signal(1,kleenex);
  70.     if ((fp=fopen(file, "w")) == NULL) {
  71.         fprintf(stderr, "File not writeable: %s\n", file);
  72.         kleenex(0);
  73.     }
  74.     printf("File '%s' ready for to be received.......\n", file);
  75.     printf("Type ^X to exit, xtrans ignores signals\n");
  76.     fflush(stdin);
  77.     new.c_iflag = IGNBRK|IGNPAR;
  78.     new.c_oflag = 0;
  79.     new.c_lflag = 0;
  80.     new.c_cc[4] = 1;
  81.     new.c_cflag &= ~PARENB;
  82.     new.c_cflag |= CS8;
  83.     ioctl(1, TCSETAW, &new);
  84.     if (remote==1){
  85.         int i;
  86.         sprintf(remote_name,"\033ux%s\032",argv[optind+1]);
  87.         for (i=0;remote_name[i];i++)
  88.             if (remote_name[i]=='/') remote_name[i] = '\\';
  89.         write(1,remote_name,strlen(remote_name));
  90.         }
  91.     else sleep(10);
  92.     write(1, &nak, 1);
  93.     while (1) {
  94. TOP:
  95.         i = get_x_char(10, &inch);
  96.         if (i == -1) {
  97.             if (debug) fprintf(errors, "Timeout on block %d during SOH\n",blocknum);
  98.             purge_send(nak);
  99.             continue;
  100.         }
  101.         if (inch == can) {
  102.             if (debug) fprintf(errors, "CAN received at block %d\n", blocknum);
  103.             kleenex(0);
  104.         }
  105.         if (inch == eot) {
  106.             if (debug) fprintf(errors, "EOT received at block %d\n", blocknum);
  107.             break;
  108.         }
  109.         if (inch != soh) {
  110.             if (debug) fprintf(errors, "Bad SOH on block %d\n",blocknum);
  111.             purge_send(nak);
  112.             continue;
  113.         }
  114.         i = get_x_char(10, &inch);
  115.         if (i == -1 ) {
  116.             if (debug) fprintf(errors, "Timeout on block %d during blocknum\n",blocknum);
  117.             purge_send(nak);
  118.             continue;
  119.         }
  120.         if (inch != blocknum) {
  121.             if (debug) fprintf(errors, "Bad blocknum on block %d, expected %d, got %d\n",blocknum,blocknum,i);
  122.             purge_send(nak);
  123.             continue;
  124.         }
  125.         i = get_x_char(10, &inch);
  126.         if (i == -1 ) {
  127.             if (debug) fprintf(errors, "Timeout on block %d during c_blocknum\n",blocknum);
  128.             purge_send(nak);
  129.             continue;
  130.         }
  131.         if (inch != c_blocknum) {
  132.             if (debug) fprintf(errors, "Bad c_blocknum on block %d, expected %d, got %d\n",blocknum,c_blocknum,
  133.                 i);
  134.             purge_send(nak);
  135.             continue;
  136.         }
  137.         for (i=0;i<128;i++) {
  138.             j = get_x_char(10, &inch);
  139.             if (j == -1) {
  140.                 if (debug) fprintf(errors, "Timeout during block %d, during data recv, on char %d\n", blocknum,
  141.                     i);
  142.                 purge_send(nak);
  143.                 goto TOP; /* AUGGH, a GOTO. horrendous */
  144.             }
  145.             buf[i] = inch;
  146.         }
  147.         cksum = 0;
  148.         for (i=0;i<128;i++) {
  149.             cksum = cksum + buf[i];
  150.             /*if (debug) fprintf(errors,"Added %d to checksum, now %d\n",j,cksum);*/
  151.         }
  152.         cksum = cksum % 256;
  153.         i = get_x_char(10, &inch);
  154.         if (i == -1 ) {
  155.             if (debug) fprintf(errors, "Timeout on block %d during checksum\n",blocknum);
  156.             purge_send(nak);
  157.             continue;
  158.         }
  159.         if (cksum != inch) {
  160.             if (debug) fprintf(errors, "Bad checksum on block %d, expected %d, got %d\n",blocknum,cksum,i);
  161.             purge_send(nak);
  162.             continue;
  163.         }
  164.         if (debug) fprintf(errors, "Validated block %d\n",blocknum);
  165.         write(1, &ack, 1);
  166.         {int iput;
  167.          static int eot_flag = 0;
  168.          iput=128;    /* assume full buffer */
  169.          if (lfproc){
  170.              iput=0;    
  171.              for (i=0;i<128;i++){
  172.              if (buf[i] == 26){    /* MS-DOS eot */
  173.                  eot_flag = 1;  /* 1st stage */
  174.                  break;
  175.              }
  176.              if (buf[i] != 13) buf[iput++] = buf[i];
  177.              }
  178.          }
  179.          if (eot_flag < 2){
  180.              fwrite(buf,iput,1,fp);
  181.              if (eot_flag == 1) eot_flag=2; /* 2nd stage */
  182.          }
  183.         }
  184.         blocknum = (blocknum+1) % 256;
  185.         c_blocknum = 255 - blocknum;
  186.     }
  187.     write(1, &ack, 1);
  188.     sleep(1);
  189.     kleenex(0);
  190. }
  191. kleenex(x)
  192. int x;
  193. {
  194.     ioctl(1, TCSETA, &save);
  195.     if (debug) fprintf(errors, "Caught signal %d\n", x);
  196.     exit(x);
  197. }
  198. alarmfn() {
  199.     signal(14, alarmfn);
  200. }
  201. read_in(fp, buf, num)
  202. FILE *fp;
  203. char *buf;
  204. int num;
  205. {
  206.     int i;
  207.     int c;
  208.     static int cr_held = 0;
  209.  
  210.     i = 0;
  211.     if (cr_held) {
  212.         buf[i] = '\r';
  213.         i++;
  214.         cr_held = 0;
  215.     }
  216.     for(   ;i < num;i++) {
  217.         c = getc(fp);
  218.         if (c == EOF) {
  219.             return(i);
  220.         }
  221.         if (c == '\n' && lfproc) {
  222.             buf[i] = c;
  223.             if (i == 127) {
  224.                 cr_held = 1;
  225.                 return(128);
  226.             }
  227.             buf[i+1] = '\r';
  228.             i++;
  229.         }
  230.         else {
  231.             buf[i] = c;
  232.         }
  233.     }
  234.     return(i);
  235. }
  236. clear_inq() {
  237.     int j;
  238.     char ch;
  239.  
  240.     signal(14, alarmfn);
  241.     do {
  242.         j = get_x_char(2, &ch);
  243.         /*if (debug) fprintf(errors, "cleared line of %d\n", j);*/
  244.     } while (j > -1);
  245. }
  246. get_x_char(timeout, cp)
  247. int timeout;
  248. char *cp;
  249. {
  250.     int ch;
  251.     extern int errno;
  252.     int ret;
  253.  
  254.     alarm(timeout);
  255.     if ((ch=getchar()) == EOF) {
  256.         /*if (debug) fprintf(errors, "get_x_char returning read error\n");*/
  257.         /*if (debug) fprintf(errors, "Errno == %d\n", errno);*/
  258.         return(-1);
  259.     }
  260.     alarm(0);
  261.     *cp = ch;
  262.     return( ch );
  263. }
  264. purge_send(ch)
  265. char ch;
  266. {
  267.     int j;
  268.     char cp;
  269.     /*if (debug) fprintf(errors, "Begin purge_send(%d)\n", ch);*/
  270.     do {
  271.         j = get_x_char(2, &cp);
  272.     } while (j != -1);
  273.     write(1, &ch, 1);
  274.     /*if (debug) fprintf(errors, "End purge_send(%d)\n", ch);*/
  275. }
  276.